
cd '/home/dpirvu/project/paper_prefactor/'

/home/dpirvu/project/paper_prefactor


import os,sys
sys.path.append('/home/dpirvu/python_stuff/')
sys.path.append('/home/dpirvu/project/paper_prefactor/bubble_codes/')
sys.path.remove('/home/dpirvu/DarkPhotonxunWISE/hmvec-master')
print(sys.path)
from plotting import *
from bubble_tools import *
from experiment import *
from celluloid import Camera

%matplotlib inline

['/home/dpirvu/project/paper_prefactor', '/cm/shared/apps/python/python37/lib/python37.zip', '/cm/shared/apps/python/python37/lib/python3.7', '/cm/shared/apps/python/python37/lib/python3.7/lib-dynload', '', '/home/dpirvu/.local/lib/python3.7/site-packages', '/cm/shared/apps/python/python37/lib/python3.7/site-packages', '/cm/shared/apps/python/python37/lib/python3.7/site-packages/IPython/extensions', '/home/dpirvu/.ipython', '/home/dpirvu/python_stuff/', '/home/dpirvu/project/paper_prefactor/bubble_codes/']
['/home/dpirvu/project/paper_prefactor', '/cm/shared/apps/python/python37/lib/python37.zip', '/cm/shared/apps/python/python37/lib/python3.7', '/cm/shared/apps/python/python37/lib/python3.7/lib-dynload', '', '/home/dpirvu/.local/lib/python3.7/site-packages', '/cm/shared/apps/python/python37/lib/python3.7/site-packages', '/cm/shared/apps/python/python37/lib/python3.7/site-packages/IPython/extensions', '/home/dpirvu/.ipython', '/home/dpirvu/python_stuff/', '/home/dpirvu/project/paper_prefactor/bubble_codes/']


%run './bubble_codes/experiment.py'
case = 'minus'
general = get_general_model(case)
tempList, massq, right_Vmax, V, dV, Vinv, nTimeMAX, minSim, maxSim = general


tmp = 0
temp, m2, sigmafld = get_model(*general, tmp)
exp_params = [nLat, m2, temp]
print('Experiment', exp_params)

sim = 5

Experiment [2048, 0.8049999999999999, 0.13]


if True:
    philist = np.linspace(-1, 1, 1000)
    fig, ax = plt.subplots(1, 1, figsize=(3.5, 2.5))

    Vunbounded = lambda x: 0.5*x**2. - 0.25*x**4.# + x**6. * 1e-4
    for tmp in range(len(tempList)):
        temp, m2, sigmafld = get_model(*general, tmp)
        print(sigmafld)
        exp_params = np.asarray([nLat, m2, temp])

        ax.plot(philist, V(philist), label=r'$T={:.0f}$'.format(temp))
        ax.plot(sigmafld, V(sigmafld), 'go', ms=2)
        ax.plot(philist, Vunbounded(philist))
        cych = cycle(allcolors)
        for nn in np.linspace(0, 2, 5):
            col=next(cych)
            plt.plot(right_Vmax + nn*sigmafld, V(right_Vmax + nn*sigmafld), 'o', color=col, ms=2)
            plt.plot(right_Vmax + nn*sigmafld, Vunbounded(right_Vmax + nn*sigmafld), 'o', color=col, ms=2)

            nums = [V(right_Vmax + nn*sigmafld), Vunbounded(right_Vmax + nn*sigmafld)]
            print(nn, [round(ii, 4) for ii in nums])
  #  ax.set_ylim((-.1, .5))
    ax.set_xlabel(r'$\bar{\varphi}$')
    ax.set_ylabel(r'$V(\bar{\varphi},\; g)$')
    beautify(ax, bb=(1,1), times=-100)
    plt.savefig('./plots/potential.pdf')
    plt.show()

0.26545260454714126
0.0 [0.2501, 0.25]
0.5 [0.2301, 0.2299]
1.0 [0.1598, 0.1594]
1.5 [0.0224, 0.0216]
2.0 [-0.2007, -0.202]


fig, ax = plt.subplots(1, 1, figsize=(3.5, 2.5))
#plt.plot(np.arange(nLat)-nLat//2, tanh_profile(np.arange(nLat)-nLat//2, 500, -100, -30, -30))
#plt.plot(np.arange(nLat)-nLat//2, retired_tanh_profile(np.arange(nLat)-nLat//2, 500, -100, 0.5, 0.5, -100, 1))
plt.plot(np.arange(nLat)-nLat//2, retired_tanh_profile(np.arange(nLat)-nLat//2, -nLat//2, 0,       0.5, 0.5, -100, -10))
plt.plot(np.arange(nLat)-nLat//2, retired_tanh_profile(np.arange(nLat)-nLat//2, 0,        nLat//2, 0.5, 0.5, -100, 10))

plt.plot(np.arange(nLat)-nLat//2, retired_tanh_profile(np.arange(nLat)-nLat//2, -nLat//2, 0,       0., 0., -10, -10))
plt.plot(np.arange(nLat)-nLat//2, retired_tanh_profile(np.arange(nLat)-nLat//2, 0,        nLat//2, 0., 0., 10, -10))
beautify(ax)
plt.show()

No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.


if False:
    # boost factor
    dt = dx / 6.
    c = dx / (dt*5.65); print('speed of light', c)
    lightspeed = 1#c
    vCOM = 1
    beta = vCOM / c
    ga = gamma(beta)
    print(beta)
    print(ga)

    sim = 51
    path2bubblesim = bubble_sim_location(*exp_params, sim)

    fullreal, outcomenew = get_bubble_realisation(nLat, path2bubblesim)
    tdecay   = get_decay_time(fullreal)
    fullreal = centre_bubble(fullreal, tdecay)
    nCfull, nTfull, nNfull = np.shape(fullreal)

   # lim1, lim2, lim3, lim4 = nTfull-nNfull//8-2*nNfull//8, nTfull-nNfull//8, 3*nNfull//8, 5*nNfull//8
    lim1, lim2, lim3, lim4 = 0, nTfull, nNfull//2 - nTfull//2, nNfull//2 + nTfull//2 +1

    bubble = gaussian_filter(fullreal[0], 2, mode='nearest')
    bubble = np.array([bubble[lim1:lim2, lim3:lim4]])
    nC, nT, nN = np.shape(bubble)

    peak_thresh = 1000.
    print(lightspeed)
    cds = np.abs(bubble) > peak_thresh
    bubble[cds] = peak_thresh

    tcen, xcen = find_nucleation_center(bubble[0], phieq, crit_thresh, crit_rad)
    tList = np.linspace(-tcen, nT-1-tcen, nT)
    xList = np.linspace(-xcen, nN-1-xcen, nN)

    ax = simple_imshow(bubble, xList, tList, contour=True, title='Test', ret=True)
    ax.plot(-5+xList,             tList+110, 'r', ls='--', lw=1)
    ax.plot(-5+xList*lightspeed,  tList+110, 'b', ls='--', lw=1)
    ax.plot(-5+xList,            -tList+110-np.abs(tList[0]+tList[-1]), 'r', ls='--', lw=1)
    ax.plot(-5+xList*lightspeed, -tList+110-np.abs(tList[0]+tList[-1]), 'b', ls='--', lw=1)

    ax.set_xlim(xList[0],xList[-1])
    ax.set_ylim(tList[0],tList[-1])
  #  ax.set_xlim(-200,200)
  #  ax.set_ylim(-200,200)
    beautify(ax); plt.tight_layout(); plt.show()


%run './bubble_codes/plotting.py'
%run './bubble_codes/bubble_tools.py'

['/home/dpirvu/project/paper_prefactor/bubble_codes', '/home/dpirvu/project/paper_prefactor', '/cm/shared/apps/python/python37/lib/python37.zip', '/cm/shared/apps/python/python37/lib/python3.7', '/cm/shared/apps/python/python37/lib/python3.7/lib-dynload', '', '/home/dpirvu/.local/lib/python3.7/site-packages', '/cm/shared/apps/python/python37/lib/python3.7/site-packages', '/cm/shared/apps/python/python37/lib/python3.7/site-packages/IPython/extensions', '/home/dpirvu/.ipython', '/home/dpirvu/python_stuff/', '/home/dpirvu/project/paper_prefactor/bubble_codes/', '/home/dpirvu/project/paper_prefactor/bubble_codes/', '/home/dpirvu/project/paper_prefactor/bubble_codes/', '/home/dpirvu/project/paper_prefactor/bubble_codes/']

<Figure size 640x480 with 0 Axes>


#crit_thresh = right_Vmax + 2*sigmafld
#crit_rad    = 20
crit_thresh = right_Vmax + 4.*sigmafld
peak_thresh = 40#20#right_Vmax + 200.*sigmafld
tv_thresh   = 40#20#right_Vmax + 200.*sigmafld
crit_rad    = 20

lightspeed = 1

threshm, threshM = right_Vmax + 0.*sigmafld, right_Vmax + 5.*sigmafld
ampList = np.linspace(threshm, threshM, 50)
print([round(ii, 2) for ii in ampList])

winsize = 150 #np.array(np.linspace(crit_rad*2, crit_rad*3, 5), dtype='int')
plots= False

[1.0, 1.03, 1.05, 1.08, 1.11, 1.14, 1.16, 1.19, 1.22, 1.24, 1.27, 1.3, 1.33, 1.35, 1.38, 1.41, 1.43, 1.46, 1.49, 1.51, 1.54, 1.57, 1.6, 1.62, 1.65, 1.68, 1.7, 1.73, 1.76, 1.79, 1.81, 1.84, 1.87, 1.89, 1.92, 1.95, 1.98, 2.0, 2.03, 2.06, 2.08, 2.11, 2.14, 2.17, 2.19, 2.22, 2.25, 2.27, 2.3, 2.33]


if True:
    for sim in range(100):
       # path2bubblesim = bubble_sim_location(*exp_params, sim)
       # fullreal, outcomenew = get_bubble_realisation(nLat, path2bubblesim)
       # tdecay   = get_decay_time(fullreal)
       # fullreal = centre_bubble(fullreal, tdecay)

        path2cleansim = clean_sim_location(*exp_params, sim)
        if not os.path.exists(path2cleansim): continue
        print('Starting simulation, temp:', sim, temp)

        fullreal = np.load(path2cleansim)
        nCfull, nTfull, nNfull = np.shape(fullreal)

     #   lim1, lim2, lim3, lim4 = 10, nTfull-nNfull//8, nNfull//4, 3*nNfull//4
     #   fullreal = fullreal[:, lim1:lim2, lim3:lim4] # this is to speed up the boosting

        bubble = fullreal[0]
        
        cds = np.abs(bubble) > peak_thresh
        bubble[cds] = peak_thresh

        bubble = gaussian_filter(bubble, 3, mode='nearest')
     #   bubble = np.array([bubble[lim1:lim2, lim3:lim4]])
        bubble = np.array([bubble])
        nC, nT, nN = np.shape(bubble)

        tcen, xcen = find_nucleation_center(bubble[0], phieq, crit_thresh, crit_rad)
        tList = np.linspace(-tcen, nT-1-tcen, nT)
        xList = np.linspace(-xcen, nN-1-xcen, nN)

   #     tcenfull, xcenfull = tcen+lim1, xcen+lim3
        tcenfull, xcenfull = tcen, xcen
        tListfull = np.linspace(-tcenfull, nTfull-1-tcenfull, nTfull)
        xListfull = np.linspace(-xcenfull, nNfull-1-xcenfull, nNfull)

    #    print('tcen, xcen', tcen, xcen, 'tcenfull, xcenfull', tcenfull, xcenfull)
    #    simple_imshow(fullreal, xListfull, tListfull, contour=False, title='Original', ret=False, cmap='RdBu')
    #    simple_imshow(bubble, xList, tList, contour=True, title='Test', ret=False)

        bool, vellist = True, []
        vCOMmeas, varmeas = find_COM_vel(bubble, ampList, winsize, nLat, lightc, phieq, tv_thresh, crit_thresh, crit_rad, plots)
        if np.isnan(vCOMmeas):
            print('Dead end at step 0.')
            bool = False

        st = 0

        if False:
            while np.abs(vCOMmeas) >= 0.03 and bool:
                if len(vellist) > 0:
                    copy = np.copy(fullreal)[:1]

                    cds = np.abs(copy) > peak_thresh
                    copy[cds] = peak_thresh

                    wcop = get_totvel_from_list(vellist)
                    x, t, copy = boost_bubble(copy, tcenfull, xcenfull, wcop, lightspeed)
                    vTest, _ = find_COM_vel(copy, ampList, winsize, nLat, lightc, phieq, tv_thresh, crit_thresh, crit_rad, False)
                    print('Upon testing this value, we re-measured vTest compared to vCOMmeas', vTest, vCOMmeas)
                    if np.abs(vTest) < 0.03:
                        vCOMmeas = vTest
                        break
                    if np.abs(vTest) > np.abs(vellist[-1]):
                        vCOMmeas = np.sign(vCOMmeas) * random.randint(5, 10)/10.

          #      print('Before', np.shape(bubble), len(tList), len(xList))
          #      simple_imshow(bubble, xList, tList, contour=True, title='Before')

                st+=1
                vellist.append(vCOMmeas); print('Step', st, 'vels collected:', vellist);
                t, x, bubble = boost_bubble(bubble, tcen, xcen, vCOMmeas, lightspeed)

          #      print('After', np.shape(bubble), len(t), len(x))
          #      simple_imshow(bubble, x, t, contour=True, title='After')

                vCOMmeas, varmeas = find_COM_vel(bubble, ampList, winsize, nLat, lightc, phieq, tv_thresh, crit_thresh, crit_rad, plots)
                if np.isnan(vCOMmeas):
                    print('Dead end.')
                    bool = False

        if bool:
       #     print('Simulation, temp:', sim, temp, 'doing final step.')
            vellist.append(vCOMmeas)
            totvel = get_totvel_from_list(vellist)

            simple_imshow(fullreal, xListfull, tListfull, contour=False, title='Original')
            t, x, fullreal2save = boost_bubble(fullreal, tcenfull, xcenfull, totvel, lightspeed)
            simple_imshow(fullreal2save, x, t, contour=False, title='Final result')
            
            for ii, wth in enumerate([fullreal[0], fullreal2save[0]]):
                nT, nN = np.shape(wth)
                t_centre, x_centre = find_nucleation_center(wth, phieq, crit_thresh, crit_rad)
                tl_stop, tr_stop = int(max(0, t_centre - winsize)), int(min(nT, t_centre + winsize//2))
                xl_stop, xr_stop = int(max(0, x_centre - winsize)), int(min(nN, x_centre + winsize))
                wth = wth[tl_stop:tr_stop, xl_stop:xr_stop]
                nT, nN = np.shape(wth)
                tcen, xcen = find_nucleation_center(wth, phieq, crit_thresh, crit_rad)
                t, x = np.linspace(-tcen, nT-1-tcen, nT), np.linspace(-xcen, nN-1-xcen, nN)
                test = 2
                cds = np.abs(wth) > test
                wth[cds] = test
                simple_imshow([wth], x, t, title=[r'Original zoom',r'Final zoom'][ii], contour=False, ret=False)

            path2RESTsim = rest_sim_location(*exp_params, sim)
            np.save(path2RESTsim, np.array([sim, fullreal2save, totvel/lightspeed]))
            print('Saved. Total final velocity, vellist:', totvel/lightspeed, vellist)

    print('All Done.')

Starting simulation, temp: 2 0.13

/home/dpirvu/.local/lib/python3.7/site-packages/numpy/core/fromnumeric.py:3441: RuntimeWarning: Mean of empty slice.
  out=out, **kwargs)
/home/dpirvu/.local/lib/python3.7/site-packages/numpy/core/_methods.py:189: RuntimeWarning: invalid value encountered in double_scalars
  ret = ret.dtype.type(ret / rcount)
/home/dpirvu/project/paper_prefactor/bubble_codes/bubble_tools.py:200: RuntimeWarning: invalid value encountered in sqrt
  hyperbola  = lambda t, d, e, f: - np.sqrt(f + e*t + t**2.) + d
/home/dpirvu/project/paper_prefactor/bubble_codes/bubble_tools.py:189: RuntimeWarning: invalid value encountered in sqrt
  hyperbola  = lambda t, a, b, c: np.sqrt(c + b*t + t**2.) + a
No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.

No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.

No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.

No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.

/cm/shared/apps/python/python37/lib/python3.7/site-packages/ipykernel_launcher.py:106: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.

Saved. Total final velocity, vellist: -0.09206013319873875 [-0.09206013319873875]
Starting simulation, temp: 3 0.13

No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.

No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.

No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.


sim = 20

path2cleansim = clean_sim_location(*exp_params, sim)
orig = np.load(path2cleansim)

path2RESTsim = rest_sim_location(*exp_params, sim)
sim, fullreal, totvel = np.load(path2RESTsim, allow_pickle=True)
print('Total boost', totvel)

Total boost 0.6838331446904234


win = 100
peak = 3

fig, ax = plt.subplots(1, 2, figsize = (8, 6))
for ii, bubble in enumerate([orig[0], fullreal[0]]):
   # tcen, xcen = find_nucleation_center(bubble, phieq, crit_thresh, crit_rad)
   # tList = np.linspace(-tcen, nT-1-tcen, nT)
   # xList = np.linspace(-xcen, nN-1-xcen, nN)
   # simple_imshow([bubble], xList, tList, contour=False)

    cds = np.abs(bubble) > peak
    bubble[cds] = peak

    nT, nN = np.shape(bubble)
    tcen, xcen = find_nucleation_center2(bubble, phieq, crit_thresh, crit_rad)
    tList = np.linspace(-tcen, nT-1-tcen, nT)
    xList = np.linspace(-xcen, nN-1-xcen, nN)

    tl,tr = max(0, tcen-win), min(nT-1, tcen+win)
    xl,xr = max(0, xcen-win), min(nN-1, xcen+win)

    bubble2plot = bubble[tl:tr,xl:xr]
    nT, nN = np.shape(bubble2plot)
    tcen, xcen = find_nucleation_center2(bubble2plot, phieq, crit_thresh, crit_rad)
   
    if ii == 1:
        xcen-=2
        tcen-=10
    else:
        tcen-=10
        
        
    tList = np.linspace(-tcen, nT-1-tcen, nT)
    xList = np.linspace(-xcen, nN-1-xcen, nN)

    if ii == 0:
        vmin = np.min(bubble2plot)
        vmax = np.max(bubble2plot)

    simple_imshow_continue(ax[ii], bubble2plot, xList, tList, vmin, vmax, contour=False)

    ax[ii].plot(xList           ,  xList, 'r', lw=1)
    ax[ii].plot(xList*lightspeed,  xList, 'b', lw=1)
    ax[ii].plot(xList           , -xList-np.abs(xList[0]+xList[-1]), 'r', lw=1)
    ax[ii].plot(xList*lightspeed, -xList-np.abs(xList[0]+xList[-1]), 'b', lw=1)

    ax[ii].set_xlim(xList[0],xList[-1])
    ax[ii].set_ylim(tList[0],tList[-1])

    ax[ii].set_xlabel(r'$x$')
    ax[ii].set_ylabel(r'$t$')

beautify(ax, times=-70)
plt.tight_layout()
plt.show()

No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.
No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.


lightspeed

1


0.4/lightspeed

0.4


path = decay_times_file(*exp_params, minSim, maxSim, nTimeMAX)
if os.path.exists(path):
    print(path)
    decay_times = np.load(path)

    minDecTime = nLat*2//3
    alltimes   = decay_times[:,1]
    simList2Do = decay_times[alltimes>=minDecTime, 0]

    remain = []
    for sim in simList2Do:
        path2RESTsim = rest_sim_location(*exp_params, sim)
        if not os.path.exists(path2RESTsim):
            
            path2CLEANsim = clean_sim_location(*exp_params, sim)
            if os.path.exists(path2CLEANsim):
                remain.append(sim)

   # print('Remaining sims to compute:', remain)
    print('Totalling:', len(remain))

/gpfs/dpirvu/prefactor/x2048_m2eff0.8050_T0.1300_minSim0_maxSim200_up_to_nTMax500000_timedecays.npy
Totalling: 101


if False:
    np.save('./plots/leftover_sims_2do_'+batch_params(*exp_params), remain)

    remain2check = np.load('./plots/leftover_sims_2do_'+batch_params(*exp_params)+'.npy')
    print(len(remain2check))


if False:
    donelist = []
    for sim in remain2check:
        path2RESTsim = rest_sim_location(*exp_params, sim)
        if os.path.exists(path2RESTsim):
            print('Sim', sim)
            sim, bubble, totbeta = np.load(path2RESTsim)
            donelist.append(sim)
            print('had total vel:', totbeta)

            if True:
                crit_rad = 50
                crit_thresh = right_Vmax.x + 2.*sigmafld
                win = 150

                tcen, xcen = find_nucleation_center(bubble[0], phieq, crit_thresh, crit_rad)
                nT, nN = np.shape(bubble[0])
                tl,tr = max(0, tcen-win), min(nT-1, tcen+win)
                xl,xr = max(0, xcen-win), min(nN-1, xcen+win)

                fig, ax = plt.subplots(1, 1, figsize = (8, 5))
                ext = [xl,xr,tl,tr]
                im = plt.imshow(bubble[0,tl:tr,xl:xr], interpolation='none', extent=ext, origin='lower', cmap='RdBu')
                clb = plt.colorbar(im, ax = ax)
                plt.grid(True, ls='--', color='darkgray')
                plt.title('Simulation '+str(sim))
                plt.plot(xcen,tcen,'bo')
                plt.xlabel('x'); plt.ylabel('t')
                plt.show()


if False:
    for sim in [

    ]:
        path2RESTsim = rest_sim_location(*exp_params, sim)
        if os.path.exists(path2RESTsim):
            os.remove(path2RESTsim)


if False:
    for sim in remain:
        path2CLEANsim = clean_sim_location(*exp_params, sim)
        bubble, sim, tdecay, outcome = np.load(path2CLEANsim)
        nC, nT, nN = np.shape(bubble)

        fig, ax = plt.subplots(1, 1, figsize = (8, 5))
        ext = [0, nN, 0, nT]
        im  = plt.imshow(bubble[0], interpolation='none', extent=ext, origin='lower', cmap='RdBu')
        clb = plt.colorbar(im, ax = ax)
        plt.grid(True, ls='--', color='darkgray')
        plt.title('Simulation '+str(sim))
        plt.xlabel('x'); plt.ylabel('t')
        plt.show()


if False:
    for sim in []:
        path2CLEANsim = clean_sim_location(*exp_params, sim)
        if os.path.exists(path2CLEANsim):
            print(path2CLEANsim)
            os.remove(path2CLEANsim)


if False:
    aa=0
    div=2

    decay_times = np.load(decay_times_file(*exp_params, minSim, maxSim, nTimeMAX))
    done_sims   = np.array([sim for sim in decay_times[:,0] if os.path.exists(rest_sim_location(*exp_params, sim))])
    decay_times = np.array([decay_times[sind] for sind, ss in enumerate(decay_times[:,0]) if ss not in done_sims])

    minDecTime = nLat*2//3
    alltimes    = decay_times[:,1]
    simList2Do  = decay_times[alltimes>=minDecTime, 0]
    n2Do        = len(simList2Do)
    print('N = ', n2Do,'simulations to deboost.')

    ranges2Do   = np.array(np.linspace(0, n2Do, div), dtype='int')
    divdata     = np.asarray([(ii,jj) for ii,jj in zip(ranges2Do[:-1], ranges2Do[1:])])
    asim, bsim  = divdata[aa]

    ranList = simList2Do[asim : bsim]
    random.shuffle(ranList)
    print('Here we\'re deboosting the following sims:', asim, bsim, ranList)

    threshm, threshM = right_Vmax.x + 0.3*sigmafld, right_Vmax.x + 2.*sigmafld
    ampList = np.linspace(threshm, threshM, 50)

    crit_rad = 50
    winsize  = int(crit_rad*2.5) #np.array(np.linspace(crit_rad*2, crit_rad*3, 5), dtype='int')
    crit_thresh = right_Vmax.x + 2.*sigmafld

    plots=True

    print('Looking at at lambda, T, phi0, m2, sigma:', lamb, temp, phi0, m2(lamb), sigmafld)


%run './bubble_codes/bubble_tools.py'

['/home/dpirvu/project/paper_prefactor/bubble_codes', '/home/dpirvu/project/paper_prefactor', '/cm/shared/apps/python/python37/lib/python37.zip', '/cm/shared/apps/python/python37/lib/python3.7', '/cm/shared/apps/python/python37/lib/python3.7/lib-dynload', '', '/home/dpirvu/.local/lib/python3.7/site-packages', '/cm/shared/apps/python/python37/lib/python3.7/site-packages', '/cm/shared/apps/python/python37/lib/python3.7/site-packages/IPython/extensions', '/home/dpirvu/.ipython', '/home/dpirvu/python_stuff/', '/home/dpirvu/project/paper_prefactor/bubble_codes/', '/home/dpirvu/project/paper_prefactor/bubble_codes/', '/home/dpirvu/project/paper_prefactor/bubble_codes/', '/home/dpirvu/project/paper_prefactor/bubble_codes/', '/home/dpirvu/project/paper_prefactor/bubble_codes/']

<Figure size 640x480 with 0 Axes>


if False:
    for sim in ranList[:1]:
        print('Starting simulation, temp, lambda:', sim, temp, lamb)
        path2CLEANsim = clean_sim_location(*exp_params, sim)
        fullreal, sim, tdecay, outcome = np.load(path2CLEANsim)

        fullreal = fullreal[:,-nLat:-nLat//4,nLat//4:-nLat//4] # this is to speed up the boosting
        bubble = fullreal[:1]
        
        nC, nT, nN = np.shape(bubble)
        simple_imshow(bubble[0], [0,nT,0,nN], 'Original')

        maxwin = 200
        tcen, xcen = find_nucleation_center(bubble[0], phieq, crit_thresh, crit_rad)
        nC, nT, nN = np.shape(bubble)
        tl,tr = max(0, tcen-maxwin), min(nT-1, tcen+maxwin)
        xl,xr = max(0, xcen-maxwin), min(nN-1, xcen+maxwin)

        fig, ax = plt.subplots(1, 1, figsize = (15, 6))
        ext = [xl,xr,tl,tr]
        im = plt.imshow(bubble[0,tl:tr,xl:xr], interpolation='none', extent=ext, origin='lower', cmap='Spectral')
        clb = plt.colorbar(im, ax = ax)
        plt.plot(xcen,tcen,'bo'); plt.xlabel('x'); plt.ylabel('t'); plt.show()

        bool, vellist = True, []
        beta = find_COM_vel(bubble, ampList, winsize, nLat, lightc, phieq, crit_thresh, crit_rad, 1., plots)
        if np.isnan(beta):
            print('Simulation, temp, lambda:', sim, temp, lamb, 'dead end at step 0.')
            bool = False

        while np.abs(beta) >= 0.03 and bool:

            if len(vellist) > 0:
                copy = fullreal[:1]
                wcop = get_totvel_from_list(vellist)
                copy = boost_bubble(copy, nLat, lightc, phieq, wcop, crit_thresh, crit_rad, normal)
                vcop = find_COM_vel(copy, ampList, winsize, nLat, lightc, phieq, crit_thresh, crit_rad, 1., plots)
                print('vcop, beta', vcop, beta)
                if np.abs(vcop) < 0.03:
                    beta = vcop
                    break
                if np.abs(vcop) > np.abs(vellist[-1]):
                    beta = np.sign(beta) * 0.1

            vellist.append(beta); print(vellist)

            nC, nT, nN = np.shape(bubble)
            simple_imshow(bubble[0], [0,nT,0,nN], 'Before')

            bubble = boost_bubble(bubble, nLat, lightc, phieq, beta, crit_thresh, crit_rad, normal)
            nC, nT, nN = np.shape(bubble)
            simple_imshow(bubble[0], [0,nT,0,nN], 'After')

            beta = find_COM_vel(bubble, ampList, winsize, nLat, lightc, phieq, crit_thresh, crit_rad, 1., plots)
            if np.isnan(beta):
                print('Simulation, temp, lambda:', sim, temp, lamb, ': dead end.')
                bool = False

        if bool:
            print('Simulation, temp, lambda:', sim, temp, lamb, 'doing final step.')
            vellist.append(beta)
            totbeta  = get_totvel_from_list(vellist)

            fullreal = boost_bubble(fullreal, nLat, lightc, phieq, totbeta, crit_thresh, crit_rad, normal)
            nC, nT, nN = np.shape(fullreal)
            simple_imshow(fullreal[0], [0,nT,0,nN], 'Final result')

            fullreal = space_save(fullreal, lightc, phieq, crit_thresh, crit_rad, nLat)
            nC, nT, nN = np.shape(fullreal)
            simple_imshow(fullreal[0], [0,nT,0,nN], 'Final result shrinked')

            path2RESTsim = rest_sim_location(*exp_params, sim)
            np.save(path2RESTsim, np.array([sim, fullreal, totbeta]))
            print('Saved. Total final velocity, vellist:', totbeta, vellist)

    print('All Done.')


if False:
    ampList0 = np.linspace(phieq + 4.5*sigmafld, phieq + 5.*sigmafld, 1)
    xList = np.arange(120, 2*crit_rad, 50)

    path_clean_sim = clean_sim_location(nLat, lamb, phi0, temp, sim)
    fullreal, sim, tdecay, outcome = np.load(path_clean_sim+'.npy')
    bubble = np.asarray([fullreal[0, -nLat:]]) # this is to speed up the boosting

    nC, nT, nN = np.shape(bubble)
    real = bubble[0]
    t_cen, x_centre = find_nucleation_center(real, phieq, crit_thresh, crit_rad)
    t_max_width = find_t_max_width(real, lightc, phieq, crit_thresh, crit_rad, t_cen-nLat)
    if t_cen > t_max_width:
        t_cen = t_max_width

    t_centre, x_centre = find_nucleation_center(real[:t_cen], phieq, crit_thresh, crit_rad)
    t_stop = min(t_centre + crit_rad//2, t_max_width)
    #if nLat > 1024 and temp == 0: real = gaussian_filter(real, 1., mode='nearest')

    betas = np.zeros((len(ampList0), len(xList)))
    for xx, x_size in enumerate(xList):
        for vv, v_size in enumerate(ampList0):
            vel_plots = True
            betas[vv, xx] = get_COM_velocity(real, phieq, crit_thresh, crit_rad, t_cen, t_stop, v_size, x_size, dx2plot, vel_plots)


if False:
    path_sim = bubble_at_rest(nLat, lamb, phi0, temp, sim)
    sim, fullreal, totbeta, beta = np.load(path_sim+'.npy')
    bubble = np.asarray([fullreal[0, -nLat:]]) # this is to speed up the boosting

    nC, nT, nN = np.shape(bubble)
    real = bubble[0]
    t_cen, x_centre = find_nucleation_center(real, phieq, crit_thresh, crit_rad)
    t_max_width = find_t_max_width(real, lightc, phieq, crit_thresh, crit_rad, t_cen-nLat)
    if t_cen > t_max_width:
        t_cen = t_max_width

    t_centre, x_centre = find_nucleation_center(real[:t_cen], phieq, crit_thresh, crit_rad)
    t_stop = min(t_centre + crit_rad//2, t_max_width)
    #if nLat > 1024 and temp == 0: real = gaussian_filter(real, 1., mode='nearest')

    betas = np.zeros((len(ampList0), len(xList)))
    for xx, x_size in enumerate(xList):
        for vv, v_size in enumerate(ampList0):
            vel_plots = True
            betas[vv, xx] = get_COM_velocity(real, phieq, crit_thresh, crit_rad, t_cen, t_stop, v_size, x_size, dx2plot, vel_plots)

Deboost Bubbles¶